#include "../include/led.h"
#include "../include/config.h"   // 添加统一配置管理头文件
#include "../include/i2sfft.h"   // 修正路径
#include "../include/ledcolor.h" // 添加LED颜色控制头文件
#include "../include/debug.h"    // 添加调试输出头文件

extern I2SFFTProcessor *i2sFftProcessor; // 声明全局变量

// 全局重置标志 - 用于段数变化时强制重置频谱静态数组
bool g_forceSpectrumReset = false;

// 定义当前灯带模式
LedStripMode currentLedStripMode = LED_MODE_WALL;

// 静态成员初始化
LEDController *LEDController::instance_ = nullptr;

// 构造函数
LEDController::LEDController()
{
    // 从全局配置中获取保存的效果类型
    currentMode_ = g_config.effectType;
    Serial.printf("[初始化] 使用保存的模式: %s(%d)\n",
                  getEffectName((EffectType)currentMode_), currentMode_);

    // 从全局配置中获取LED配置
    segmentSize_ = g_config.ledsPerSegment;
    segmentNum_ = g_config.segments;

    // 初始化频谱灯柱方向 - 根据当前灯带模式设置
    spectrumReversed_ = (currentLedStripMode == LED_MODE_WALL);
    Serial.printf("[LED] 频谱灯柱方向: %s\n", spectrumReversed_ ? "反转" : "正常");

    // 只有在频谱模式下才初始化bands_数组
    if (currentMode_ == LED_MODE_SPECTRUM)
    {
        // 立即初始化bands_数组以避免未初始化错误
        if (g_config.segments > 0)
        {
            numBands_ = g_config.segments;
            bands_ = new float[numBands_]();        // 动态分配并初始化为0
            smoothedBands = new float[numBands_](); // 初始化smoothedBands数组
            Serial.printf("[LED构造] 频谱模式 - 初始化bands_数组: %p, 段数: %d\n", bands_, numBands_);
            Serial.printf("[LED构造] 频谱模式 - 初始化smoothedBands数组: %p, 段数: %d\n", smoothedBands, numBands_);
        }
        else
        {
            // 使用默认值
            numBands_ = 8;
            bands_ = new float[numBands_]();
            smoothedBands = new float[numBands_]();
            Serial.printf("[LED构造] 频谱模式 - 使用默认段数初始化bands_数组: %p, 段数: %d\n", bands_, numBands_);
            Serial.printf("[LED构造] 频谱模式 - 使用默认段数初始化smoothedBands数组: %p, 段数: %d\n", smoothedBands, numBands_);
        }
    }
    else
    {
        // 非频谱模式，不初始化bands_数组
        bands_ = nullptr;
        smoothedBands = nullptr;
        numBands_ = 0;
        Serial.printf("[LED构造] 非频谱模式(%s) - 跳过bands_数组初始化\n",
                      getEffectName((EffectType)currentMode_));
    }

    // 调试输出LED配置信息
    Serial.printf("[LED] 初始化LED灯带: 引脚=%d, 每段LED=%d, 段数=%d, 总数=%d (从配置加载)\n",
                  LED_PIN, segmentSize_, segmentNum_, segmentSize_ * segmentNum_);
    Serial.print("[LED] 灯带类型: WS2815 (兼容WS2813)");
    Serial.println();

    // 初始化LED控制器 - 针对WS2815调整颜色顺序为RGB
    FastLED.addLeds<WS2813, LED_PIN, RGB>(leds_, segmentSize_ * segmentNum_)
        .setCorrection(TypicalLEDStrip);

    // ==================== 修复亮度初始化问题 ====================
    // 从全局配置中加载亮度，而不是使用固定的DEFAULT_BRIGHTNESS
    uint8_t configBrightness = map(g_config.brightness, 10, 100, 25, 255);
    FastLED.setBrightness(configBrightness);

    if (DEBUG_SERIAL)
    {
        Serial.printf("[LED构造] 应用配置亮度: %d%% -> FastLED亮度: %d\n",
                      g_config.brightness, configBrightness);
    }

    // 测试LED初始化
    FastLED.clear();
    // fill_solid(leds_, 10, CRGB::Red); // 点亮前10个LED为红色
    // FastLED.show();
    delay(200);
}

// 析构函数
LEDController::~LEDController()
{
    // 释放动态分配的数组
    if (bands_)
    {
        delete[] bands_;
        bands_ = nullptr;
    }
    if (smoothedBands)
    {
        delete[] smoothedBands;
        smoothedBands = nullptr;
    }
}

// 更新LED配置
void LEDController::updateLEDConfig()
{
    Serial.println("[LED配置更新] 开始更新LED配置...");

    // 保存旧配置用于比较
    uint16_t oldSegmentSize = segmentSize_;
    uint16_t oldSegmentNum = segmentNum_;
    uint8_t oldNumBands = numBands_;

    // 从全局配置中获取最新的LED配置
    segmentSize_ = g_config.ledsPerSegment;
    segmentNum_ = g_config.segments;

    // 检查配置是否真的发生了变化
    bool configChanged = (oldSegmentSize != segmentSize_) || (oldSegmentNum != segmentNum_);

    if (!configChanged)
    {
        Serial.println("[LED配置更新] 配置未变化，跳过更新");
        return;
    }

    // 验证新配置的有效性
    if (segmentSize_ < MIN_LEDS_PER_SEGMENT || segmentSize_ > MAX_LEDS_PER_SEGMENT ||
        segmentNum_ < MIN_SEGMENTS || segmentNum_ > MAX_SEGMENTS)
    {
        Serial.printf("[LED配置更新] 错误: 无效配置 - 每段LED=%d, 段数=%d\n", segmentSize_, segmentNum_);
        // 恢复旧配置
        segmentSize_ = oldSegmentSize;
        segmentNum_ = oldSegmentNum;
        return;
    }

    uint16_t newTotalLEDs = segmentSize_ * segmentNum_;
    if (newTotalLEDs > LED_COUNT)
    {
        Serial.printf("[LED配置更新] 错误: 总LED数超限 - 新总数=%d, 最大允许=%d\n", newTotalLEDs, LED_COUNT);
        // 恢复旧配置
        segmentSize_ = oldSegmentSize;
        segmentNum_ = oldSegmentNum;
        return;
    }

    Serial.printf("[LED配置更新] 配置变化: 每段LED %d->%d, 段数 %d->%d, 总数 %d->%d\n",
                  oldSegmentSize, segmentSize_, oldSegmentNum, segmentNum_,
                  oldSegmentSize * oldSegmentNum, newTotalLEDs);

    // 1. 首先停止所有LED显示，避免在重新配置期间出现异常
    FastLED.clear();
    FastLED.show();
    delay(50); // 确保显示已清除

    // 2. 安全地重新分配 bands_ 和 smoothedBands 数组
    float *oldBands = bands_;
    float *oldSmoothedBands = smoothedBands;
    bands_ = nullptr; // 先设置为空指针，避免在分配过程中意外访问
    smoothedBands = nullptr;

    try
    {
        // 分配新的bands_数组和smoothedBands数组
        numBands_ = segmentNum_;
        bands_ = new float[numBands_]();
        smoothedBands = new float[numBands_]();
        Serial.printf("[LED配置更新] 分配新bands_数组: %p (大小:%d)\n", bands_, numBands_);
        Serial.printf("[LED配置更新] 分配新smoothedBands数组: %p (大小:%d)\n", smoothedBands, numBands_);

        // 成功分配后才释放旧数组
        if (oldBands)
        {
            Serial.printf("[LED配置更新] 释放旧bands_数组: %p (大小:%d)\n", oldBands, oldNumBands);
            delete[] oldBands;
        }
        if (oldSmoothedBands)
        {
            Serial.printf("[LED配置更新] 释放旧smoothedBands数组: %p (大小:%d)\n", oldSmoothedBands, oldNumBands);
            delete[] oldSmoothedBands;
        }
    }
    catch (...)
    {
        Serial.println("[LED配置更新] 错误: 内存分配失败");
        // 恢复旧配置和指针
        bands_ = oldBands;
        smoothedBands = oldSmoothedBands;
        numBands_ = oldNumBands;
        segmentSize_ = oldSegmentSize;
        segmentNum_ = oldSegmentNum;
        return;
    }

    // 3. 重新初始化 FastLED - 使用安全的方式
    Serial.println("[LED配置更新] 重新初始化FastLED...");

    // 清除当前LED数据
    memset(leds_, 0, sizeof(CRGB) * LED_COUNT);

    // 重新应用亮度设置（不重新初始化FastLED控制器，避免潜在问题）
    uint8_t configBrightness = map(g_config.brightness, 10, 100, 25, 255);
    FastLED.setBrightness(configBrightness);

    // 强制清除并显示
    FastLED.clear();
    FastLED.show();

    Serial.printf("[LED配置更新] FastLED重新配置完成 - 总LED数: %d\n", newTotalLEDs);

    // 4. 如果当前是频谱模式，需要清理相关静态数组状态
    if (currentMode_ == LED_MODE_SPECTRUM)
    {
        Serial.println("[LED配置更新] 当前为频谱模式，重置频谱效果状态");
        resetSpectrumStaticArrays();
    }

    // 5. 验证配置更新结果
    Serial.printf("[LED配置更新] 配置更新完成 - 每段LED=%d, 段数=%d, 总数=%d\n",
                  segmentSize_, segmentNum_, newTotalLEDs);
    Serial.printf("[LED配置更新] bands_数组: %p, 大小: %d\n", bands_, numBands_);

    // 6. 执行一次安全的测试显示，确保配置正确
    int testLEDs = min(5, (int)newTotalLEDs); // 只点亮前几个LED进行测试
    fill_solid(leds_, testLEDs, CRGB::Blue);  // 使用蓝色进行测试
    FastLED.show();
    delay(100);
    FastLED.clear();
    FastLED.show();

    Serial.println("[LED配置更新] LED配置更新成功完成");
}

// 获取单例实例
LEDController &LEDController::instance()
{
    if (!instance_)
    {
        instance_ = new LEDController();
    }
    return *instance_;
}

// 初始化模式
void LEDController::initMode()
{
    // 使用保存的模式
    currentMode_ = g_config.effectType;
    Serial.printf("[模式初始化] 使用保存的模式: %s(%d)\n",
                  getEffectName((EffectType)currentMode_), currentMode_);
    FastLED.clear();
    update();
}

// 检查并更新模式 - 简化版本，不再从EEPROM读取
void LEDController::checkAndUpdateMode()
{
    // 此函数不再需要检查EEPROM
    // 模式更新由setMode()函数直接处理
    // 保留此函数以兼容现有代码
}

// 设置亮度
void LEDController::setBrightness(uint8_t brightness)
{
    FastLED.setBrightness(brightness);
}

// 设置颜色
void LEDController::setColor(CRGB color)
{
    currentColor_ = color;
}

// 设置速度
void LEDController::setSpeed(uint8_t speed)
{
    effectSpeed_ = speed;
}

// 设置当前模式
void LEDController::setMode(uint8_t mode)
{
    Serial.printf("[模式设置] 请求设置模式: %s(%d)\n",
                  getEffectName((EffectType)mode), mode);
    Serial.printf("[模式设置] 当前模式: %s(%d)\n",
                  getEffectName((EffectType)currentMode_), currentMode_);

    if (mode >= LED_MODE_SOLID && mode < LED_MODE_COUNT)
    {
        // 1. 立即更新模式
        currentMode_ = mode;

        // 2. 强制清除显示并重置状态
        FastLED.clear();
        FastLED.show();
        delay(50); // 确保清除完成

        // 3. 根据新模式重置效果状态
        switch (mode)
        {
        case LED_MODE_RAINBOW:
            hue = 0; // 重置彩虹色调
            break;
        case LED_MODE_WATERFALL:
            // 重置瀑布流状态
            fill_solid(leds_, LED_COUNT, CRGB::Black);
            break;
        case LED_MODE_FIRE:
            // 重置火焰效果状态
            fill_solid(leds_, LED_COUNT, CRGB::Black);
            break;
        case LED_MODE_SPECTRUM:
            // 进入频谱模式时，确保bands_数组已初始化
            if (!bands_ || numBands_ <= 0)
            {
                Serial.println("[模式切换] 重新初始化频谱数组");
                if (g_config.segments > 0)
                {
                    numBands_ = g_config.segments;
                    bands_ = new float[numBands_]();
                }
                else
                {
                    numBands_ = 8;
                    bands_ = new float[numBands_]();
                }
                Serial.printf("[模式切换] 频谱数组重新初始化完成: %p, 段数: %d\n", bands_, numBands_);
            }
            break;
        }

        // 4. 更新并显示新效果
        update();
        FastLED.show();
        delay(50); // 确保显示完成

        // 5. 记录成功日志
        Serial.printf("[模式设置] 成功设置模式为: %s(%d)\n",
                      getEffectName((EffectType)currentMode_), currentMode_);
        Serial.printf("[模式验证] 立即检查模式: %d\n", currentMode_);
    }
    else
    {
        Serial.printf("[模式设置] 错误: 无效的模式值 %d\n", mode);
        Serial.printf("[模式设置] 当前保持模式: %s(%d)\n",
                      getEffectName((EffectType)currentMode_), currentMode_);
    }

    // 最终验证
    uint8_t verifiedMode = currentMode_;
    Serial.printf("[最终验证] 当前模式: %s(%d)\n",
                  getEffectName((EffectType)verifiedMode), verifiedMode);
    if (verifiedMode != mode && mode < LED_MODE_COUNT)
    {
        Serial.println("[严重错误] 模式设置验证失败!");
    }
}

// 设置频谱数据
void LEDController::setBands(float *bands, uint8_t numBands)
{
    // 安全释放旧 bands_，避免重复释放
    if (bands_ && bands_ != bands)
    {
        delete[] bands_;
    }
    bands_ = bands;
    numBands_ = numBands;
}

// 更新效果
void LEDController::update()
{
    // 更新全局颜色控制器的动画
    LEDColorController::instance().update();

    // Serial.printf("[LED] 当前模式: %d\n", currentMode_);

    switch (currentMode_)
    {
    case LED_MODE_SOLID: // 纯色模式
        // Serial.println("[LED] 纯色模式");
        fill_solid(leds_, LED_COUNT, currentColor_);
        break;
    case LED_MODE_RAINBOW: // 彩虹模式
        // Serial.println("[LED] 彩虹模式");
        updateRainbow();
        break;
    case LED_MODE_WATERFALL: // 瀑布模式
        // Serial.println("[LED] 瀑布模式");
        updateWaterfall();
        break;
    case LED_MODE_SPECTRUM: // 频谱模式
        // Serial.println("[LED] 频谱模式");
        updateSpectrum();
        break;
    case LED_MODE_RAINBOW_FLOW: // 七彩流水效果
        // Serial.println("[LED] 七彩流水效果");
        updateRainbowFlow();
        break;
    default:
        // Serial.println("[LED] 未知模式");
        fill_solid(leds_, LED_COUNT, CRGB::Red); // 默认红色显示错误
    }

    // 应用灯带模式
    switch (currentLedStripMode)
    {
    case LED_MODE_WALL:
        // 墙面模式处理
        applyWallMode();
        break;
    case LED_MODE_FLOW:
        // 流动模式处理
        applyFlowMode();
        break;
    }

    FastLED.show();
}

void LEDController::applyWallMode()
{
    // 墙面模式实现 - 所有LED显示相同效果
    // 已由主效果模式处理
}

// 流动模式处理
void LEDController::applyFlowMode()
{
    // 实现瀑布效果
    for (int i = LED_COUNT - 1; i > 0; i--)
    {
        leds_[i] = leds_[i - 1];
    }
    leds_[0] = CHSV(beat8(effectSpeed_), 255, 255);
}

// 第二个频谱
void LEDController::updateWaterfall()
{
}

// LED测试功能
void LEDController::testLEDs()
{
    // 测试所有LED是否正常响应
    FastLED.clear();
    for (uint16_t seg = 0; seg < segmentNum_; seg++)
    {
        for (uint16_t led = 0; led < segmentSize_; led++)
        {
            uint16_t index = seg * segmentSize_ + led;
            leds_[index] = CRGB::Red; // 点亮当前LED为红色
            FastLED.show();
            delay(50);                  // 短暂延时以便观察
            leds_[index] = CRGB::Black; // 关闭当前LED
        }
    }
}

// 频谱效果更新 - 添加动态平滑效果
void LEDController::updateSpectrum()
{
    // ==================== 非频谱模式早期返回检查 ====================
    // 如果当前不是频谱模式，直接返回，避免不必要的处理
    if (currentMode_ != LED_MODE_SPECTRUM)
    {
        Serial.println("[频谱跳过] 当前非频谱模式，跳过频谱处理");
        return;
    }

    // ==================== 基本检查 ====================
    if (!bands_ || numBands_ <= 0)
    {
        Serial.println("[LED错误] bands_数组未初始化");
        return;
    }

    // ==================== 配置有效性检查 ====================
    // 确保配置中的段数大于0，避免分配0大小的数组
    if (g_config.segments <= 0)
    {
        Serial.println("[频谱跳过] 配置段数为0，跳过频谱处理");
        return;
    }

    // ==================== 段数变化检测和静态数组重置机制 ====================
    static bool forceReset = false;
    static int lastConfigSegments = -1;

    // 检查是否需要强制重置（由resetSpectrumStaticArrays触发）
    extern bool g_forceSpectrumReset;
    if (g_forceSpectrumReset)
    {
        forceReset = true;
        g_forceSpectrumReset = false;
        Serial.println("[频谱重置] 检测到外部重置请求");
    }

    // 检查段数配置是否变化
    if (g_config.segments != lastConfigSegments)
    {
        forceReset = true;
        Serial.printf("[频谱重置] 检测到段数变化: %d -> %d\n", lastConfigSegments, g_config.segments);
        lastConfigSegments = g_config.segments;
    }

    // ==================== 调试变量 ====================
    static uint32_t lastDebugTime = 0;
    static bool shouldDebug = true; // 调试开关

    // 获取分段配置
    int bandsCount = g_config.segments;
    int segmentSize = g_config.ledsPerSegment;

    // ==================== 动态平滑效果所需的静态变量 ====================
    static float *localSmoothedBands = nullptr; // 重命名避免与成员变量冲突
    static float *targetBands = nullptr;
    static int lastBandsCount = 0;

    // 初始化平滑数组
    if (bandsCount != lastBandsCount || localSmoothedBands == nullptr || forceReset)
    {
        if (localSmoothedBands)
            delete[] localSmoothedBands;
        if (targetBands)
            delete[] targetBands;
        localSmoothedBands = new float[bandsCount]();
        targetBands = new float[bandsCount]();
        lastBandsCount = bandsCount;
        Serial.printf("[LED平滑] 初始化平滑数组: %d个频段 (强制重置: %s)\n", bandsCount, forceReset ? "是" : "否");
    }

    // ==================== 从I2SFFTProcessor获取目标值 ====================
    if (i2sFftProcessor)
    {
        if (!i2sFftProcessor->getInstantAudioBands(targetBands, bandsCount))
        {
            Serial.println("[LED] 获取音频频段失败");
            return;
        }
    }
    else
    {
        Serial.println("[LED] 音频处理器不可用");
        return;
    }

    // ==================== 新增：LED层面的静音检测保护机制 ====================
    // 这是在I2SFFTProcessor静音检测之外的额外保护层，确保LED在静音时完全关闭
    static uint32_t lastLEDSilenceCheck = 0;
    
    // 计算当前频段数据的总能量
    float totalLEDEnergy = 0.0f;
    float maxLEDValue = 0.0f;
    for (int i = 0; i < bandsCount; i++)
    {
        totalLEDEnergy += targetBands[i];
        if (targetBands[i] > maxLEDValue)
        {
            maxLEDValue = targetBands[i];
        }
    }
    float avgLEDEnergy = totalLEDEnergy / bandsCount;
    
    // 设置LED层面的静音检测阈值（比I2SFFTProcessor更宽松，作为后备保护）
    const float LED_SILENCE_THRESHOLD = 0.002f;     // LED平均能量静音阈值
    const float LED_MAX_VALUE_THRESHOLD = 0.005f;   // LED最大值静音阈值
    
    // 如果检测到LED层面的静音，强制关闭所有LED
    // if (avgLEDEnergy < LED_SILENCE_THRESHOLD && maxLEDValue < LED_MAX_VALUE_THRESHOLD)
    // {
    //     // 强制清零所有LED显示
    //     for (int i = 0; i < bandsCount; i++)
    //     {
    //         localSmoothedBands[i] = 0.0f;
    //         bands_[i] = 0.0f;
    //     }
        
    //     // 清空LED显示
    //     fill_solid(leds_, LED_COUNT, CRGB::Black);
        
    //     // 每隔一段时间输出静音检测日志
    //     if (millis() - lastLEDSilenceCheck > 3000)
    //     {
    //         Serial.printf("[LED静音保护] 检测到LED层静音 - 平均能量:%.6f(阈值:%.6f), 最大值:%.6f(阈值:%.6f)\n",
    //                       avgLEDEnergy, LED_SILENCE_THRESHOLD, maxLEDValue, LED_MAX_VALUE_THRESHOLD);
    //         lastLEDSilenceCheck = millis();
    //     }
        
    //     return; // 直接返回，不进行后续的LED渲染
    // }

    // ==================== 动态平滑参数（从配置获取）====================
    float riseSpeed = g_config.riseSpeed;                 // 上升速度 (0.0-1.0)
    float fallSpeed = g_config.fallSpeed;                 // 下降速度 (0.0-1.0)
    float spectrumSmoothing = g_config.spectrumSmoothing; // 频谱平滑系数 (0.0-1.0)

    // ==================== 应用动态平滑算法 ====================
    for (int i = 0; i < bandsCount; i++)
    {
        float target = targetBands[i];
        float current = localSmoothedBands[i]; // 使用重命名后的变量

        // 根据上升/下降方向选择不同的平滑速度
        if (target > current)
        {
            // 上升：使用上升速度和冲击效果
            float riseRate = riseSpeed + (target - current) * 2.0f; // 冲击越大上升越快
            riseRate = constrain(riseRate, 0.1f, 1.0f);
            localSmoothedBands[i] = current + (target - current) * riseRate;
        }
        else
        {
            // 下降：使用下降速度
            float fallRate = fallSpeed;
            if (target < current * 0.1f)
            {
                // 如果目标值很小（接近静音），加速下降
                fallRate *= 2.0f;
            }
            fallRate = constrain(fallRate, 0.05f, 1.0f);
            localSmoothedBands[i] = current + (target - current) * fallRate;
        }

        // 应用额外的频谱平滑
        if (spectrumSmoothing > 0.0f)
        {
            localSmoothedBands[i] = localSmoothedBands[i] * (1.0f - spectrumSmoothing) +
                                    current * spectrumSmoothing;
        }

        // 确保值在有效范围内
        localSmoothedBands[i] = constrain(localSmoothedBands[i], 0.0f, 1.0f);

        // 提高小值过滤阈值，进一步减少LED微弱闪烁
        if (localSmoothedBands[i] < 0.01f)
        {
            localSmoothedBands[i] = 0.0f;
        }
    }

    // ==================== 更新bands_数组为平滑后的值 ====================
    for (int i = 0; i < bandsCount; i++)
    {
        bands_[i] = localSmoothedBands[i]; // 使用重命名后的变量
    }

    // ==================== 峰值点处理（修复停留时间功能）====================
    static float *peakDotPosition = nullptr;
    static uint32_t *peakHoldStartTime = nullptr; // 新增：峰值点停留开始时间
    static bool *peakIsHolding = nullptr;         // 新增：峰值点是否正在停留
    static float *lastDisplayHeight = nullptr;    // 新增：记录上次灯柱高度，用于检测上升状态
    static int lastPeakBandsCount = 0;

    if (bandsCount != lastPeakBandsCount || peakDotPosition == nullptr || forceReset)
    {
        if (peakDotPosition)
            delete[] peakDotPosition;
        if (peakHoldStartTime)
            delete[] peakHoldStartTime;
        if (peakIsHolding)
            delete[] peakIsHolding;
        if (lastDisplayHeight)
            delete[] lastDisplayHeight;

        peakDotPosition = new float[bandsCount]();
        peakHoldStartTime = new uint32_t[bandsCount]();
        peakIsHolding = new bool[bandsCount]();
        lastDisplayHeight = new float[bandsCount](); // 初始化上次高度数组
        lastPeakBandsCount = bandsCount;

        Serial.printf("[峰值点] 初始化峰值点数组，包含停留时间功能: %d个频段 (强制重置: %s)\n", bandsCount, forceReset ? "是" : "否");
    }

    // ==================== 获取视觉效果参数（非音频处理参数）====================
    // 只保留LED渲染所需的视觉效果参数，音频处理参数已移至I2SFFTProcessor

    // 峰值点效果参数 - 控制峰值点的视觉动画效果
    const float peakHoldTime = g_config.peakHoldTime;         // 峰值点停留时间
    const float peakDotDecay = g_config.peakDotDecay;         // 峰值点衰减速度
    const float impactSpeed = g_config.impactSpeed;           // 冲击上升速度
    const int maxImpactDistance = g_config.maxImpactDistance; // 最大冲击距离

    // 计算停留时间（毫秒），将0.0-1.0映射到0-2000ms
    uint32_t holdTimeMs = (uint32_t)(peakHoldTime * 2000.0f);

    // 颜色循环参数 - 控制峰值点颜色变化
    const uint32_t colorCycleTime = max(2000U, g_config.colorCycleTime * 1000U); // 颜色循环时间（毫秒），最小2秒

    // 视觉效果状态变量
    static uint8_t flowPosition = 0; // 流水位置（内部状态）
    uint32_t currentTime = millis();
    // 修复峰值点颜色变换时间控制：使用更合理的颜色循环逻辑
    static uint8_t lastPeakHue = 0;
    static uint32_t lastColorUpdateTime = 0;

    // 根据用户配置的颜色循环时间动态计算更新间隔
    // colorCycleTime 以毫秒为单位，将完整循环时间分配到256个色调上
    uint32_t configCycleTimeMs = g_config.colorCycleTime;
    uint32_t colorUpdateInterval;

    if (configCycleTimeMs > 0)
    {
        // 将完整的颜色循环时间分配到256个色调上
        // 每个色调的持续时间 = 总循环时间 / 256
        colorUpdateInterval = configCycleTimeMs / 256;

        // 确保更新间隔在合理范围内（50ms - 2000ms）
        colorUpdateInterval = constrain(colorUpdateInterval, 50, 2000);
    }
    else
    {
        // 如果配置异常，使用默认值
        colorUpdateInterval = 150;
    }

    if (currentTime - lastColorUpdateTime >= colorUpdateInterval)
    {
        // 根据更新间隔调整颜色步长，确保颜色变化明显
        uint8_t colorStep = 1;
        if (colorUpdateInterval > 500)
        {
            colorStep = 1; // 慢速变化时每次增加1
        }
        else if (colorUpdateInterval > 200)
        {
            colorStep = 2; // 中速变化时每次增加2
        }
        else
        {
            colorStep = 3; // 快速变化时每次增加3
        }

        lastPeakHue = (lastPeakHue + colorStep) % 256;
        lastColorUpdateTime = currentTime;

        // 调试输出颜色变化信息
        // if (lastPeakHue % 32 == 0) { // 每32个色调输出一次
        //     Serial.printf("[颜色循环] 配置时间: %dms, 更新间隔: %dms, 当前色调: %d\n",
        //                  configCycleTimeMs, colorUpdateInterval, lastPeakHue);
        // }
    }
    uint8_t globalPeakHue = lastPeakHue;

    // ==================== LED渲染循环 ====================
    for (int i = 0; i < numBands_; i++)
    {
        // 使用平滑后的值计算LED显示高度
        float smoothedValue = bands_[i]; // 现在使用平滑后的值

        // 计算LED显示高度
        int displayHeight = (int)(smoothedValue * segmentSize);
        displayHeight = constrain(displayHeight, 0, segmentSize - 1);

        // ==================== 峰值点视觉效果（使用平滑后的LED灯柱值）====================
        // 🔧 修改：峰值点冲击计算使用LED灯柱平滑后的值，而不是FFT原始值
        // 这样可以让峰值点的表现更加平滑和一致，避免因FFT抖动导致的突兀跳跃
        float targetPeakHeight = smoothedValue * segmentSize; // 峰值点使用平滑后的LED灯柱值

        // 放宽上升阈值，让峰值点更容易被触发
        float riseThreshold = max(2.0f, segmentSize * 0.1f); // 降低上升阈值，更容易触发

        // 放宽峰值点碰撞检测条件：
        // 1. 峰值点在灯柱顶端附近（原条件）
        // 2. 或者灯柱正在上升且会碰到峰值点（新增条件）
        bool isAtColumnTop = abs(peakDotPosition[i] - displayHeight) <= 1.0f; // 放宽误差范围

        // 检测灯柱是否在上升并且会碰到峰值点
        bool columnRisingTowardsPeak = (float)displayHeight > lastDisplayHeight[i] + 0.3f && // 灯柱在上升
                                       displayHeight >= peakDotPosition[i] - 2.0f;           // 灯柱接近或碰到峰值点

        // 放宽的上冲条件：峰值点在顶端附近 OR 灯柱上升碰到峰值点
        bool allowRise = (isAtColumnTop || columnRisingTowardsPeak) &&
                         (targetPeakHeight > peakDotPosition[i] + riseThreshold);

        if (allowRise)
        {
            // 峰值点上升动画 - 增强响应性
            float impactHeight = targetPeakHeight + maxImpactDistance;
            impactHeight = min(impactHeight, (float)(segmentSize - 1));
            float heightDiff = impactHeight - peakDotPosition[i];

            // 根据碰撞类型调整上升速度
            float effectiveImpactSpeed = impactSpeed;
            if (columnRisingTowardsPeak && !isAtColumnTop)
            {
                // 如果是灯柱上升碰撞触发的，增加冲击速度
                effectiveImpactSpeed *= 1.5f;
            }

            peakDotPosition[i] += heightDiff * effectiveImpactSpeed * 0.2f; // 稍微提高冲击速度
            if (peakDotPosition[i] > impactHeight)
            {
                peakDotPosition[i] = impactHeight;
            }

            // 峰值点达到新高度时，开始停留计时
            peakHoldStartTime[i] = currentTime;
            peakIsHolding[i] = true;

            // 调试输出碰撞信息
            // if (columnRisingTowardsPeak && !isAtColumnTop) {
            //     Serial.printf("[峰值点碰撞] 频段%d: 灯柱上升碰撞触发上冲, 灯柱高度:%.1f->%.1f, 峰值点:%.1f->%.1f\n",
            //                  i, lastDisplayHeight[i], (float)displayHeight,
            //                  peakDotPosition[i] - heightDiff * effectiveImpactSpeed * 0.2f, peakDotPosition[i]);
            // }
        }
        else if (peakDotPosition[i] > displayHeight + 0.5f)
        {
            // 峰值点高于灯柱顶端时，检查是否需要停留
            if (peakIsHolding[i])
            {
                // 正在停留期间，检查停留时间是否结束
                if (currentTime - peakHoldStartTime[i] >= holdTimeMs)
                {
                    // 停留时间结束，开始衰减
                    peakIsHolding[i] = false;
                }
                else
                {
                    // 还在停留期间，保持位置不变 - 不要用continue，让LED正常渲染
                    // 峰值点位置保持不变，但灯柱要正常显示
                }
            }

            // 如果不在停留状态或停留时间结束，进行正常衰减
            if (!peakIsHolding[i])
            {
                float oldPosition = peakDotPosition[i];
                float decayStep = max(0.5f, peakDotDecay * segmentSize * 0.1f);
                peakDotPosition[i] -= decayStep;
                if (peakDotPosition[i] < displayHeight)
                {
                    peakDotPosition[i] = displayHeight; // 确保不会低于灯柱顶端
                }
            }
        }
        else
        {
            // 峰值点与灯柱顶端粘连时，保持原有的弹跳检测逻辑
            // 检测灯柱是否在上升
            bool columnIsRising = (float)displayHeight > lastDisplayHeight[i] + 0.5f;

            if (columnIsRising && displayHeight > 2)
            {
                // 当灯柱上升时，给峰值点一个小弹跳
                float bounceHeight = displayHeight + (maxImpactDistance * 0.3f);
                bounceHeight = min(bounceHeight, (float)(segmentSize - 1));
                peakDotPosition[i] = bounceHeight;

                // 开始停留计时
                peakHoldStartTime[i] = currentTime;
                peakIsHolding[i] = true;
            }
            else
            {
                // 正常情况：峰值点与灯柱顶端粘连
                peakDotPosition[i] = displayHeight;
                peakIsHolding[i] = false; // 重置停留状态
            }
        }

        // 峰值点范围限制
        if (peakDotPosition[i] >= segmentSize)
        {
            peakDotPosition[i] = segmentSize - 1;
        }
        if (peakDotPosition[i] < 0.1f)
        {
            peakDotPosition[i] = 0;
            peakIsHolding[i] = false; // 重置停留状态
        }

        // 更新上次灯柱高度记录
        lastDisplayHeight[i] = (float)displayHeight;

        // ==================== 调试输出（显示平滑效果）====================
        // 调用LED数值链调试输出函数
        debugLEDValueChain(i, bandsCount, targetBands, localSmoothedBands[i], displayHeight, segmentSize);

        // ==================== LED颜色渲染（使用全局颜色控制系统）====================
        CRGB *segmentStart = leds_ + segmentSize * i;
        fill_solid(segmentStart, segmentSize, CRGB::Black);

        // 获取全局颜色控制器实例
        auto &colorController = LEDColorController::instance();

        // 绘制频谱灯柱 - 使用全局颜色方案
        if (i % 2 == 1)
        {
            // 奇数段反转显示
            for (int j = 0; j < displayHeight; j++)
            {
                float relHeight = (float)j / segmentSize;
                uint8_t brightness = 180 + relHeight * 75;
                // 传递当前条索引i和总条数g_config.segments，实现独立彩虹色
                CRGB segmentColor = colorController.getColorForPosition(relHeight, brightness, i, g_config.segments);
                segmentStart[segmentSize - 1 - j] = segmentColor;
            }

            // ==================== 峰值点渲染（应用用户配置）====================
            // 检查峰值点是否启用（峰值点数量大于0）
            if (g_config.peakDotCount > 0)
            {
                int peakPos = (int)peakDotPosition[i];
                uint8_t peakBrightness = 200 + (sin8(millis() / 10) >> 6);

                // 根据用户配置选择峰值点颜色
                CRGB peakColor;
                switch (g_config.peakDotColor)
                {
                case 0: // 七彩/彩虹色
                    peakColor = CHSV(globalPeakHue, 255, peakBrightness);
                    break;
                case 1: // 红色
                    peakColor = CRGB(peakBrightness, 0, 0);
                    break;
                case 2: // 绿色
                    peakColor = CRGB(0, peakBrightness, 0);
                    break;
                case 3: // 蓝色
                    peakColor = CRGB(0, 0, peakBrightness);
                    break;
                case 4: // 黄色
                    peakColor = CRGB(peakBrightness, peakBrightness, 0);
                    break;
                case 5: // 白色
                    peakColor = CRGB(peakBrightness, peakBrightness, peakBrightness);
                    break;
                // 🔧 修复4：添加缺失的峰值点颜色6-9，防止系统重启
                case 6: // 紫色 (HSV: 200度)
                    peakColor = CHSV(200, 255, peakBrightness);
                    break;
                case 7: // 青色 (HSV: 128度)
                    peakColor = CHSV(128, 255, peakBrightness);
                    break;
                case 8: // 橙色 (HSV: 16度)
                    peakColor = CHSV(16, 255, peakBrightness);
                    break;
                case 9:                                         // 粉色 (HSV: 224度)
                    peakColor = CHSV(224, 200, peakBrightness); // 降低饱和度使其更粉嫩
                    break;
                default: // 默认使用彩虹色（作为安全回退）
                    peakColor = CHSV(globalPeakHue, 255, peakBrightness);
                    break;
                }

                if (peakPos >= displayHeight && peakPos < segmentSize)
                {
                    // 显示主峰值点LED
                    segmentStart[segmentSize - 1 - peakPos] = peakColor;

                    // 根据配置显示第二个峰值点
                    if (g_config.peakDotCount >= 2 && peakPos > 0)
                    {
                        // 第二个峰值点使用稍低的亮度
                        CRGB secondPeakColor = peakColor;
                        secondPeakColor.nscale8(204); // 80%亮度
                        segmentStart[segmentSize - 1 - (peakPos - 1)] = secondPeakColor;
                    }
                }
                else if (displayHeight > 0)
                {
                    // 峰值点低于灯柱顶时，直接显示在灯柱顶
                    segmentStart[segmentSize - 1 - displayHeight] = peakColor;

                    // 根据配置显示第二个峰值点
                    if (g_config.peakDotCount >= 2 && displayHeight > 0)
                    {
                        CRGB secondPeakColor = peakColor;
                        secondPeakColor.nscale8(204); // 80%亮度
                        segmentStart[segmentSize - 1 - (displayHeight - 1)] = secondPeakColor;
                    }
                }
            }
        }
        else
        {
            // 偶数段正常显示
            for (int j = 0; j < displayHeight; j++)
            {
                float relHeight = (float)j / segmentSize;
                uint8_t brightness = 180 + relHeight * 75;
                // 传递当前条索引i和总条数g_config.segments，实现独立彩虹色
                CRGB segmentColor = colorController.getColorForPosition(relHeight, brightness, i, g_config.segments);
                segmentStart[j] = segmentColor;
            }

            // ==================== 峰值点渲染（应用用户配置）====================
            // 检查峰值点是否启用（峰值点数量大于0）
            if (g_config.peakDotCount > 0)
            {
                int peakPos = (int)peakDotPosition[i];
                uint8_t peakBrightness = 200 + (sin8(millis() / 10) >> 6);

                // 根据用户配置选择峰值点颜色
                CRGB peakColor;
                switch (g_config.peakDotColor)
                {
                case 0: // 七彩/彩虹色
                    peakColor = CHSV(globalPeakHue, 255, peakBrightness);
                    break;
                case 1: // 红色
                    peakColor = CRGB(peakBrightness, 0, 0);
                    break;
                case 2: // 绿色
                    peakColor = CRGB(0, peakBrightness, 0);
                    break;
                case 3: // 蓝色
                    peakColor = CRGB(0, 0, peakBrightness);
                    break;
                case 4: // 黄色
                    peakColor = CRGB(peakBrightness, peakBrightness, 0);
                    break;
                case 5: // 白色
                    peakColor = CRGB(peakBrightness, peakBrightness, peakBrightness);
                    break;
                // 🔧 修复4：添加缺失的峰值点颜色6-9，防止系统重启
                case 6: // 紫色 (HSV: 200度)
                    peakColor = CHSV(200, 255, peakBrightness);
                    break;
                case 7: // 青色 (HSV: 128度)
                    peakColor = CHSV(128, 255, peakBrightness);
                    break;
                case 8: // 橙色 (HSV: 16度)
                    peakColor = CHSV(16, 255, peakBrightness);
                    break;
                case 9:                                         // 粉色 (HSV: 224度)
                    peakColor = CHSV(224, 200, peakBrightness); // 降低饱和度使其更粉嫩
                    break;
                default: // 默认使用彩虹色（作为安全回退）
                    peakColor = CHSV(globalPeakHue, 255, peakBrightness);
                    break;
                }

                if (peakPos >= displayHeight && peakPos < segmentSize)
                {
                    // 显示主峰值点LED
                    segmentStart[peakPos] = peakColor;

                    // 根据配置显示第二个峰值点
                    if (g_config.peakDotCount >= 2 && peakPos + 1 < segmentSize)
                    {
                        // 第二个峰值点使用稍低的亮度
                        CRGB secondPeakColor = peakColor;
                        secondPeakColor.nscale8(204); // 80%亮度
                        segmentStart[peakPos + 1] = secondPeakColor;
                    }
                }
                else if (displayHeight > 0)
                {
                    // 峰值点低于灯柱顶时，直接显示在灯柱顶
                    segmentStart[displayHeight] = peakColor;

                    // 根据配置显示第二个峰值点
                    if (g_config.peakDotCount >= 2 && displayHeight + 1 < segmentSize)
                    {
                        CRGB secondPeakColor = peakColor;
                        secondPeakColor.nscale8(204); // 80%亮度
                        segmentStart[displayHeight + 1] = secondPeakColor;
                    }
                }
            }
        }
    }

    // 更新视觉效果状态
    flowPosition = (flowPosition + 1) % 256;

    // ==================== 清除强制重置标志 ====================
    if (forceReset)
    {
        forceReset = false;
        Serial.println("[频谱重置] 静态数组重置完成，清除重置标志");
    }

    // ==================== 移除阻塞性延迟 ====================
    // 原来的 delay(5) 会阻塞整个系统，影响时序协调
    // 改为依赖主循环的时序控制，确保平滑效果
}

// 彩虹效果
void LEDController::updateRainbow()
{
    // 获取全局颜色控制器实例
    auto &colorController = LEDColorController::instance();
    
    // 确保颜色控制器使用彩虹色方案
    colorController.setColorScheme(COLOR_RAINBOW);
    
    // 为每个LED计算颜色，让 getRainbowColor 处理所有动画逻辑
    for (int i = 0; i < LED_COUNT; i++)
    {
        // 计算LED位置（0.0-1.0）
        float position = (float)i / LED_COUNT;
        
        // 使用LEDColorController的getColorForPosition，它会调用getRainbowColor
        // 传递索引和总数，让getRainbowColor处理速度、平滑、方向等参数
        uint8_t brightness = 255; // 使用最大亮度
        CRGB color = colorController.getColorForPosition(position, brightness, i, LED_COUNT);
        
        leds_[i] = color;
    }
}

// ==================== 七彩流水效果 ====================
void LEDController::updateRainbowFlow()
{
    // 使用 effectSpeed_ 控制流动的速度
    // speed: 1-255, 调整 beat8 的频率
    uint8_t speed = map(effectSpeed_, 0, 255, 1, 32); // 将速度映射到更合适的范围
    uint16_t totalLeds = getTotalLEDs();
    uint8_t hue = beat8(speed); // 使用 beat8 创建平滑变化的色调

    for (uint16_t i = 0; i < totalLeds; i++)
    {
        // 创建一个随位置变化的色调偏移，形成渐变
        // g_config.spectrumSmoothing (平滑度) 控制渐变的宽度
        // 映射平滑度到 1-64 的范围，值越小，渐变越宽
        uint8_t hue_offset = map(i, 0, totalLeds, 0, 255 / (map(g_config.spectrumSmoothing, 0, 100, 1, 64)));
        leds_[i] = CHSV(hue + hue_offset, 255, 255);
    }
}

// ==================== 彩虹波浪效果 ====================
void LEDController::updateRainbowWave()
{
    // 使用 effectSpeed_ 控制波浪的速度
    uint8_t speed = map(effectSpeed_, 0, 255, 10, 40);
    uint16_t totalLeds = getTotalLEDs();

    // g_config.spectrumSmoothing (平滑度) 控制波浪的宽度
    // 映射平滑度到 1-10 的范围，值越大，波浪越窄
    uint8_t wave_width = map(g_config.spectrumSmoothing, 0, 100, 1, 10);

    for (uint16_t i = 0; i < totalLeds; i++)
    {
        // 使用 sin8 创建平滑的亮度变化，形成波浪
        // i * wave_width 控制波浪的密度
        uint8_t brightness = sin8(beat8(speed) + i * wave_width);
        // 色调随时间变化
        uint8_t hue = beat8(speed / 2);
        leds_[i] = CHSV(hue, 255, brightness);
    }
}

// ==================== 能量脉冲效果 ====================
void LEDController::updateEnergyPulse()
{
    // 实现能量脉冲效果
    // 通过调整LED亮度和颜色实现脉冲效果
    static uint32_t lastPulseTime = 0;
    uint32_t currentTime = millis();

    // 控制脉冲速度和强度
    uint8_t pulseSpeed = map(effectSpeed_, 0, 255, 5, 50);
    uint8_t pulseIntensity = map(g_config.brightness, 10, 100, 25, 255);

    for (int i = 0; i < LED_COUNT; i++)
    {
        // 计算每个LED的脉冲亮度
        uint8_t brightness = 0;
        if (currentTime - lastPulseTime < pulseSpeed)
        {
            // 在脉冲上升期间，亮度线性增加
            brightness = map(currentTime - lastPulseTime, 0, pulseSpeed, 0, pulseIntensity);
        }
        else if (currentTime - lastPulseTime < pulseSpeed * 2)
        {
            // 在脉冲下降期间，亮度线性减少
            brightness = map(currentTime - lastPulseTime, pulseSpeed, pulseSpeed * 2, pulseIntensity, 0);
        }

        // 应用脉冲亮度
        leds_[i] = CRGB(brightness, 0, 0); // 仅红色通道随脉冲变化
    }

    // 每隔一段时间改变一次脉冲的基准亮度
    if (currentTime - lastPulseTime >= pulseSpeed * 2)
    {
        lastPulseTime = currentTime;
    }
}

// 重置频谱效果的静态数组 - 解决段数调整时的重启问题
void LEDController::resetSpectrumStaticArrays()
{
    Serial.println("[频谱重置] 开始重置频谱效果的所有静态数组...");

    // 设置全局重置标志，让updateSpectrum在下次调用时重新分配所有静态数组
    g_forceSpectrumReset = true;

    // 为了确保重置生效，我们需要调用一次updateSpectrum
    // 但要先确保bands_数组已经正确初始化
    if (bands_ && numBands_ > 0)
    {
        Serial.printf("[频谱重置] 触发频谱函数重新初始化，段数: %d\n", numBands_);
        updateSpectrum(); // 这将触发静态数组的重新分配
    }

    Serial.println("[频谱重置] 频谱静态数组重置完成");
}

// 全局效果控制函数
bool initLEDEffects()
{

    auto &controller = LEDController::instance();
    controller.initMode(); // 确保使用保存的配置初始化模式

    // 检查当前效果模式
    EffectType currentEffect = (EffectType)controller.getCurrentMode();
    Serial.printf("[LED效果初始化] 当前效果模式: %s(%d)\n",
                  getEffectName(currentEffect), currentEffect);

    // 如果不是频谱模式，跳过频谱相关的初始化
    if (currentEffect != LED_MODE_SPECTRUM)
    {
        Serial.println("[LED效果初始化] 非频谱模式，跳过频谱配置检查");
        Serial.println("[LED效果] 初始化完成 (非频谱模式)");
        return true;
    }

    // 只有在频谱模式下才进行LED配置检查
    if (g_config.ledsPerSegment <= 0 || g_config.segments <= 0)
    {
        Serial.println("[错误] 无效的LED配置 - 请检查config");
        Serial.println("[LED效果] LED效果初始化失败!");
        return false;
    }

    // 计算总频带数(每段1个频带)
    int totalBands = g_config.segments;
    float *defaultBands = new float[totalBands](); // 动态分配并初始化为0

    controller.setBands(defaultBands, totalBands);

    Serial.printf("[LED效果] 频谱初始化完成 - 段数: %d, 每段LED: %d, 总频带: %d\n",
                  g_config.segments, g_config.ledsPerSegment, totalBands);

    Serial.printf("[LED效果] 频谱参数初始化完成 - bands_: %p, numBands_: %d\n",
                  defaultBands, totalBands); // 修复：使用totalBands而不是硬编码的8
    Serial.println("[LED效果] 初始化完成");
    return true;
}

void updateLEDEffects(float currentVolume)
{
    auto &controller = LEDController::instance();

    // 检查当前效果模式
    EffectType currentEffect = (EffectType)controller.getCurrentMode();

    // 如果是频谱模式但bands_数组未初始化，显示错误
    if (currentEffect == LED_MODE_SPECTRUM && controller.getBands() == nullptr)
    {
        Serial.println("[错误] bands_数组未初始化");
        return;
    }

    // 正常更新LED效果
    controller.update();
}

void showLEDEffects()
{
    FastLED.show();
}

void setLEDEffectsColor(CRGB color)
{
    LEDController::instance().setColor(color);
}

void setLEDEffect(EffectType effect)
{
    Serial.printf("[主程序] 请求设置LED效果: %s(%d)\n",
                  getEffectName(effect), effect);

    auto &controller = LEDController::instance();

    // 设置新模式 (setMode内部会清除显示并更新)
    controller.setMode(effect);

    // 验证设置是否成功
    uint8_t actualMode = controller.getCurrentMode();
    Serial.printf("[主程序] 设置后验证 - 当前模式: %s(%d)\n",
                  getEffectName((EffectType)actualMode), actualMode);

    // 最终确认
    if (actualMode != effect)
    {
        Serial.println("[主程序] 错误: 模式设置失败!");
    }
    else
    {
        Serial.println("[主程序] 模式设置成功");
    }
}

EffectType getCurrentEffect()
{
    return (EffectType)LEDController::instance().getCurrentMode();
}

void setEffectSpeed(uint8_t speed)
{
    LEDController::instance().setSpeed(speed);
}

void setBrightness(uint8_t brightness)
{
    LEDController::instance().setBrightness(brightness);
}

void setLedStripMode(LedStripMode mode)
{
    currentLedStripMode = mode;

    // 更新频谱灯柱方向
    auto &controller = LEDController::instance();
    controller.setSpectrumDirection(mode == LED_MODE_WALL);
    Serial.printf("[灯带模式] 设置为: %s, 频谱灯柱方向: %s\n",
                  mode == LED_MODE_WALL ? "墙面模式" : "流动模式",
                  mode == LED_MODE_WALL ? "反转" : "正常");

    // 根据模式重置LED显示
    FastLED.clear();
    FastLED.show();

    // 立即更新当前效果以应用新的灯带模式
    controller.update();
    FastLED.show();

    Serial.printf("[灯带模式] 模式切换完成，立即刷新显示\n");
}

void setColorScheme(uint8_t scheme)
{
    // 设置全局颜色方案
    setGlobalColorScheme(scheme);

    // 同时更新全局颜色控制器的动画
    LEDColorController::instance().update();

    Serial.printf("[颜色方案] 设置全局颜色方案为: %s\n",
                  getGlobalColorSchemeName(scheme));
}

// 优化LED显示更新函数，大幅提高平滑系数、最小显示阈值和峰值衰减速度，减少LED屏闪烁
void updateLEDDisplay(float *frequencyData, int bands)
{
    if (!frequencyData || bands <= 0) return;
    
    static float smoothedValues[LED_COUNT] = {0};
    static float peakValues[LED_COUNT] = {0};
    static uint32_t lastUpdateTime = 0;
    
    uint32_t currentTime = millis();
    float deltaTime = (currentTime - lastUpdateTime) / 1000.0f;
    lastUpdateTime = currentTime;
    
    // 大幅提高平滑系数，减少LED闪烁
    float smoothingFactor = g_config.spectrumSmoothing / 100.0f;
    smoothingFactor = (smoothingFactor > 0.4f) ? smoothingFactor : 0.4f; // 修复max函数问题
    
    // 大幅提高最小显示阈值 - 使用简单的条件判断代替max函数
    float minDisplayThreshold = 0.12f; // 直接设置为12%的固定阈值
    
    for (int i = 0; i < ((bands < LED_COUNT) ? bands : LED_COUNT); i++) // 修复min函数问题
    {
        float rawValue = frequencyData[i];
        
        // 应用更严格的最小阈值过滤
        if (rawValue < minDisplayThreshold)
        {
            rawValue = 0.0f;
        }
        
        // 增强平滑处理，减少突变
        smoothedValues[i] = smoothedValues[i] * (1.0f - smoothingFactor) + rawValue * smoothingFactor;
        
        // 峰值处理 - 加快峰值衰减，使用固定衰减率
        float peakDecay = 0.25f; // 固定25%的衰减速度
        
        if (smoothedValues[i] > peakValues[i])
        {
            peakValues[i] = smoothedValues[i];
        }
        else
        {
            peakValues[i] *= (1.0f - peakDecay);
            if (peakValues[i] < 0.05f) // 提高峰值清零阈值
            {
                peakValues[i] = 0.0f;
            }
        }
        
        // 最终显示值再次过滤 - 使用简单的条件判断
        float finalValue = (smoothedValues[i] > peakValues[i]) ? smoothedValues[i] : peakValues[i];
        if (finalValue < 0.1f) // 更严格的最终过滤
        {
            finalValue = 0.0f;
        }
        
        frequencyData[i] = finalValue;
    }
}
